home *** CD-ROM | disk | FTP | other *** search
/ Gekkan Dennou Club 147 / Gekkan Dennou Club - 2000.8 Vol. 147 (Japan).7z / Gekkan Dennou Club - 2000.8 Vol. 147 (Japan) (Track 1).bin / tools / zmc3v078 / zmc3v078.lzh / SRCSV078.LZH / ETC.C < prev    next >
C/C++ Source or Header  |  2000-05-31  |  7KB  |  388 lines
  1. /* =======================
  2.      low_level functions
  3.    ======================= */
  4.  
  5. #include <stdio.h>
  6. #include <stdlib.h>
  7. #include <stdarg.h>
  8. #ifdef MEMDEBUG
  9. #include <string.h>
  10. #endif
  11.  
  12. #include "config.h"
  13.  
  14. #define    FILENOTFOUND    1
  15. #define    NONZMD            2
  16. #define    ZMDVERERR        3
  17. #define    READERR            4
  18. #define    WRITEERR        5
  19. #define    FLUSHERR        6
  20. #define    SWERR            7
  21. #define    TOOMANYFILES    8
  22. #define    WAVNOTDEFIND    9
  23. #define    NOMEMORY        10
  24. #define    ILLEGALSWITCH    11
  25. #define ILLEGALMEMORY    12
  26.  
  27.  
  28.  
  29. #ifdef MEMDEBUG
  30. typedef struct memDebugData {
  31.     struct memDebugData *next;
  32.     /* struct memDebugData *prev; */
  33.     DWORD    size;        /* malloced size */
  34.     void    *adrs;        /* malloced area */
  35.     char    *label;        /* label name */
  36. } MEMDEBUGDATA;
  37.  
  38. void memdebug(void);
  39. MEMDEBUGDATA *searchHimself(void *adrs, char *label, char f);
  40. #endif
  41.  
  42. void efree(void *ptr, char *label);
  43. void *emalloc(size_t n, char *label);
  44. void *erealloc(void *ptr,size_t n, char *label);
  45. void *emarealloc(void *ptr,size_t n, char *label);
  46. void fatal(int ret,char *fmt, ...);
  47. inline WORD  getWordAlign(UBYTE*);
  48. inline DWORD getDwordAlign(UBYTE*);
  49. inline void  putWordAlign(UBYTE*,WORD);
  50. inline void  putDwordAlign(UBYTE*,DWORD);
  51. inline WORD  getWord(UBYTE*);
  52. inline DWORD getDword(UBYTE*);
  53. inline void  putWord(UBYTE*,WORD);
  54. inline void  putDword(UBYTE*,DWORD);
  55. #ifndef UNIXY_OS
  56. int iskanji(int a);
  57. #endif
  58.  
  59.  
  60. #ifndef UNIXY_OS
  61. int iskanji(int a)            /* only SJIS is supported. */
  62. {
  63.     return ((0x81 <= a && a <= 0x9F) || (0xE0 <= a && a <= 0xFC))? 1 : 0;
  64. }
  65. #endif
  66.  
  67.  
  68.  
  69. #ifdef UNIXY_OS
  70.     /* ---- for use of `ntohs' ,`ntohl', `htons', and `htonl' ---- */
  71.     #ifdef    FreeBSD
  72.         #include <sys/param.h>
  73.     #else
  74.         #include <sys/types.h>
  75.         #include <netinet/in.h>
  76.     #endif
  77. #endif    /* UNIXY_OS */
  78.  
  79.  
  80.  
  81. #ifdef MEMDEBUG
  82. static MEMDEBUGDATA memMaster = {
  83.     NULL,    /* next */
  84.     0,        /* size */
  85.     NULL,    /* adrs */
  86.     NULL    /* label */
  87. };
  88.  
  89. void memdebug(void)
  90. {
  91.     MEMDEBUGDATA *m = &memMaster;
  92.     int c = 0;
  93.  
  94.     while (m->next != NULL) {
  95.         m = m->next;
  96.         fprintf(stderr,"%p %d %s\n",m->adrs, m->size, m->label);
  97.         c++;
  98.     }
  99.     if (c) {
  100.         fprintf(stderr, "%d memory blocks are still allocated.\n", c);
  101.     }
  102. }
  103. #endif
  104.  
  105.  
  106. void efree(void *ptr, char *label)
  107. {
  108. #ifdef MEMDEBUG
  109.     MEMDEBUGDATA *m, *p, *n;
  110.     if (ptr) {
  111.         p = searchHimself(ptr, label, 'F');
  112.         m = p->next;
  113.         n = m->next;
  114.  
  115.         free(m->label);
  116.         free(m);
  117.         p->next = n;
  118.     }
  119. #endif
  120.  
  121.     if (ptr) {
  122.         free(ptr);
  123.     }
  124. }
  125.  
  126. /* =======================================
  127.      malloc function with error handling
  128.    ======================================= */
  129.  
  130. void *emalloc(size_t n, char *label)
  131. {
  132.     void *pt;
  133. #ifdef MEMDEBUG
  134.     MEMDEBUGDATA *m = &memMaster;
  135. #endif
  136.  
  137.     if ( (pt = malloc(n)) == NULL ) {
  138.         fatal(NOMEMORY,"malloc failed.\n");
  139.     }
  140.  
  141. #ifdef MEMDEBUG
  142.     while (m->next != NULL) {
  143.         m = m->next;
  144.     }
  145.  
  146.     m->next = malloc(sizeof(MEMDEBUGDATA) * 1);
  147.     if (m->next == NULL) {
  148.         fatal(NOMEMORY,"malloc failed.\n");
  149.     }
  150.  
  151.     m = m->next;
  152.     m->next = NULL;
  153.     m->size = n;
  154.     m->adrs = pt;
  155.     m->label = malloc(sizeof(char) * strlen(label) + 1);
  156.     if (m->label == NULL) {
  157.         fatal(NOMEMORY,"malloc failed.\n");
  158.     }
  159.     strcpy(m->label, label);
  160. #endif
  161.     return pt;
  162. }
  163.  
  164.  
  165.  
  166.  
  167. /* ========================================
  168.      search malloced table before
  169.      If it found himself, return the "previous" pointer
  170.      or NULL
  171.    ======================================== */
  172. #ifdef MEMDEBUG
  173. MEMDEBUGDATA *searchHimself(void *adrs, char *label, char f)
  174. {
  175.     MEMDEBUGDATA *m = &memMaster;
  176.     MEMDEBUGDATA *p = NULL;        /* previous adrs */
  177.     MEMDEBUGDATA *r = NULL;        /* return value */
  178.  
  179.     while (m->next != NULL) {
  180.         p = m;
  181.         m = m->next;
  182.         if (m->adrs == adrs) {
  183.             r = p;
  184.             break;
  185.         }
  186.     }
  187.  
  188.     if (r == NULL) {
  189.         memdebug();
  190.         fatal (ILLEGALMEMORY,"MEMORY LEAK FOUND: malloced table search failed.\n(%p [%c]%s)\n",adrs,f,label);
  191.     }
  192.     return r;
  193. }
  194. #endif
  195.  
  196. /* ========================================
  197.      realloc function with error handling
  198.    ======================================== */
  199.  
  200. void *erealloc(void *ptr, size_t n, char *label)
  201. {
  202.     void *pt;
  203. #ifdef MEMDEBUG
  204.     MEMDEBUGDATA *m = searchHimself(ptr, label, 'r');
  205. #endif
  206.  
  207.     if ( (pt = realloc(ptr,n)) == NULL ) {
  208. #ifdef MEMDEBUG
  209.         memdebug();
  210.         fprintf(stderr,"%s: %p -> %d",label, ptr,n);
  211. #endif
  212.         fatal(NOMEMORY,"realloc failed.\n");
  213.     }
  214.  
  215. #ifdef MEMDEBUG
  216.     m = m->next;
  217.     m->size = n;
  218.     m->adrs = pt;
  219.  
  220.     m->label = realloc(m->label, strlen(m->label) + strlen(label) + 1);
  221.     if (m->label == NULL) {
  222.         fatal(NOMEMORY,"realloc failed.\n");
  223.     }
  224.     strcat(m->label, label);
  225. #endif
  226.  
  227.     return pt;
  228. }
  229.  
  230.  
  231. void *emarealloc(void *ptr, size_t n, char *label)
  232. {
  233.     if ( !ptr ) {
  234.         return emalloc(n,label);
  235.     } else {
  236.         return erealloc(ptr,n,label);
  237.     }
  238. }
  239.  
  240.  
  241. /* ========================
  242.      fatal error
  243.    ======================== */
  244.  
  245. void fatal(int ret,char *fmt, ...)
  246. {
  247.     va_list ap;
  248.  
  249.     va_start(ap,fmt);
  250.     vfprintf(stderr,fmt,ap);
  251.     va_end(ap);
  252.  
  253.     exit(ret);
  254. }
  255.  
  256.  
  257. /* =========================
  258.      read WORD,DWORD data
  259.      big/little endian OK
  260.         for even-byte align only
  261.         input:pointer
  262.         output:number
  263.    ========================= */
  264.  
  265. inline WORD getWordAlign(UBYTE *zmd)
  266. {
  267. #ifdef X68000
  268.     return *(WORD*)zmd;
  269. #else
  270.     WORD data;
  271.  
  272.     data  = *zmd++ << 8;
  273.     data += *zmd;
  274.     return  data;
  275. #endif
  276. }
  277.  
  278. inline DWORD getDwordAlign(UBYTE *zmd)
  279. {
  280. #ifdef X68000
  281.     return *(DWORD*)zmd;
  282. #else
  283.     int data;
  284.  
  285.     data  = (*zmd++ << 24);
  286.     data += (*zmd++ << 16);
  287.     data += (*zmd++ <<  8);
  288.     data +=  *zmd;
  289.     return data;
  290. #endif
  291. }
  292.  
  293. /* ============================
  294.      write WORD,DWORD data
  295.      big/little endian OK
  296.         for even-byte align only
  297.         input:number,pointer
  298.    ============================ */
  299.  
  300. inline void putWordAlign(UBYTE *pos,WORD data)
  301. {
  302. #ifdef UNIXY_OS
  303.     WORD    val;
  304.     UBYTE    *ptr;
  305.  
  306.     val = htons(data);
  307.     ptr = (UBYTE*)&val;
  308.  
  309.     *pos++ = *ptr++;
  310.     *pos++ = *ptr++;
  311. #elif defined X68000
  312.     *(WORD*)pos = data;
  313. #else
  314.     *pos++ = data >> 8;
  315.     *pos   = (data & 0xFF);
  316. #endif
  317. }
  318.  
  319.  
  320. inline void putDwordAlign(UBYTE *pos,DWORD data)
  321. {
  322. #ifdef UNIXY_OS
  323.     DWORD    val;
  324.     UBYTE    *ptr;
  325.  
  326.     val = htonl(data);
  327.     ptr = (UBYTE*)&val;
  328.  
  329.     *pos++ = *ptr++;
  330.     *pos++ = *ptr++;
  331.     *pos++ = *ptr++;
  332.     *pos++ = *ptr++;
  333. #elif defined X68000
  334.     *(DWORD*)pos = data;
  335. #else
  336.     *pos++ =  data >> 24;
  337.     *pos++ = (data >> 16) & 0xFF;
  338.     *pos++ = (data >>  8) & 0xFF;
  339.     *pos   = (data & 0xFF);
  340. #endif
  341. }
  342.  
  343.  
  344. /* ============================
  345.      read WORD,DWORD data
  346.         input:pointer
  347.         output:number
  348.    ============================ */
  349.  
  350. inline WORD getWord(UBYTE *zmd)
  351. {
  352.     WORD data;
  353.  
  354.     data  = *zmd++ << 8;
  355.     data |= *zmd;
  356.     return  data;
  357. }
  358.  
  359. inline DWORD getDword(UBYTE *zmd)
  360. {
  361.     DWORD data;
  362.  
  363.     data  = (*zmd++ << 24);
  364.     data |= (*zmd++ << 16);
  365.     data |= (*zmd++ <<  8);
  366.     data |=  *zmd;
  367.     return data;
  368. }
  369.  
  370. /* ============================
  371.      write WORD,DWORD data
  372.         input:number,pointer
  373.    ============================ */
  374.  
  375. inline void putWord(UBYTE *pos,WORD data)
  376. {
  377.     *pos++ = data >> 8;
  378.     *pos   = (data & 0xFF);
  379. }
  380.  
  381. inline void putDword(UBYTE *pos,DWORD data)
  382. {
  383.     *pos++ =  data >> 24;
  384.     *pos++ = (data >> 16) & 0xFF;
  385.     *pos++ = (data >>  8) & 0xFF;
  386.     *pos   = (data & 0xFF);
  387. }
  388.